const http = require('http');
const url = require('url');

// Create an HTTP server
const server = http.createServer((req, res) => {
  // 'req' is the IncomingMessage object
  
  // Basic message properties
  console.log('HTTP Version:', req.httpVersion);
  console.log('Method:', req.method);
  console.log('URL:', req.url);
  
  // Parse the URL
  const parsedUrl = url.parse(req.url, true);
  console.log('Pathname:', parsedUrl.pathname);
  console.log('Query:', parsedUrl.query);
  
  // Headers
  console.log('Headers:', req.headers);
  console.log('User-Agent:', req.headers['user-agent']);
  
  // Raw headers with keys and values as separate array elements
  console.log('Raw Headers:', req.rawHeaders);
  
  // Socket information
  console.log('Remote Address:', req.socket.remoteAddress);
  console.log('Remote Port:', req.socket.remotePort);
  
  // Reading the message body (if any)
  let body = [];
  req.on('data', (chunk) => {
    body.push(chunk);
  });
  
  req.on('end', () => {
    body = Buffer.concat(body).toString();
    console.log('Request body:', body);
    
    // Now that we have the body, send a response
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({
      httpVersion: req.httpVersion,
      method: req.method,
      url: req.url,
      headers: req.headers,
      body: body || null
    }));
  });
  
  // Handle errors
  req.on('error', (err) => {
    console.error('Request error:', err);
    res.statusCode = 400;
    res.end('Error: ' + err.message);
  });
});

// Start server
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}/`);
  
  // Make a test request
  http.request({
    hostname: 'localhost',
    port: PORT,
    path: '/test?param1=value1¶m2=value2',
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Custom-Header': 'Custom Value'
    }
  }, (res) => {
    res.resume(); // Consume response data
  }).end('{"message":"Hello from the client!"}');
});

const http = require('http');

// Make an HTTP request
const req = http.request('http://example.com', (res) => {
  // 'res' is the IncomingMessage object (response)
  
  // Basic message properties
  console.log('Status Code:', res.statusCode);
  console.log('Status Message:', res.statusMessage);
  console.log('HTTP Version:', res.httpVersion);
  
  // Headers
  console.log('Headers:', res.headers);
  console.log('Content-Type:', res.headers['content-type']);
  console.log('Raw Headers:', res.rawHeaders);
  
  // Socket information
  console.log('Remote Address:', res.socket.remoteAddress);
  console.log('Remote Port:', res.socket.remotePort);
  
  // Reading the message body
  let body = [];
  
  // Data events emit when chunks of the body are received
  res.on('data', (chunk) => {
    body.push(chunk);
    console.log('Received chunk of', chunk.length, 'bytes');
  });
  
  // End event is emitted when the entire body has been received
  res.on('end', () => {
    body = Buffer.concat(body).toString();
    console.log('Body length:', body.length);
    console.log('Body preview:', body.substring(0, 100) + '...');
    
    // Check trailers (if any)
    console.log('Trailers:', res.trailers);
    console.log('Raw Trailers:', res.rawTrailers);
    
    // Check if message is complete
    console.log('Message complete:', res.complete);
  });
  
  // Handle message errors
  res.on('error', (err) => {
    console.error('Response error:', err);
  });
});

// Handle request errors
req.on('error', (err) => {
  console.error('Request error:', err);
});

// End the request
req.end();

const http = require('http');
const fs = require('fs');
const path = require('path');

// Create a server to handle file uploads
const server = http.createServer((req, res) => {
  if (req.method === 'POST' && req.url === '/upload') {
    // Create a write stream to a file
    const filePath = path.join(__dirname, 'uploaded-file.txt');
    const fileStream = fs.createWriteStream(filePath);
    
    // Pipe the request body directly to the file
    req.pipe(fileStream);
    
    // Handle completion
    fileStream.on('finish', () => {
      // Get file stats to check size
      fs.stat(filePath, (err, stats) => {
        if (err) {
          console.error('Error getting file stats:', err);
          res.writeHead(500, {'Content-Type': 'text/plain'});
          res.end('Error processing upload');
          return;
        }
        
        // Send response
        res.writeHead(200, {'Content-Type': 'application/json'});
        res.end(JSON.stringify({
          success: true,
          message: 'File uploaded successfully',
          size: stats.size,
          path: filePath
        }));
        
        console.log(`File uploaded to ${filePath}`);
        console.log(`File size: ${stats.size} bytes`);
        
        // Clean up the file after a delay
        setTimeout(() => {
          fs.unlink(filePath, (err) => {
            if (err) console.error('Error removing uploaded file:', err);
            else console.log('Uploaded file removed');
          });
        }, 5000);
      });
    });
    
    // Handle errors
    fileStream.on('error', (err) => {
      console.error('File write error:', err);
      res.writeHead(500, {'Content-Type': 'text/plain'});
      res.end('Error saving file');
    });
    
    req.on('error', (err) => {
      console.error('Request error:', err);
      fileStream.destroy(err);
    });
  }
  else if (req.method === 'GET' && req.url === '/') {
    // Provide a simple HTML form for uploading
    res.writeHead(200, {'Content-Type': 'text/html'});
    res.end(`
      
      
      
        
      
      
        
Upload a Text File
        

          
          Upload
        
        
Note: This is a simple example. A real implementation would need to parse multipart form data.
      
      
    `);
  }
  else {
    // Handle all other requests
    res.writeHead(404, {'Content-Type': 'text/plain'});
    res.end('Not Found');
  }
});

// Start server
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}/`);
  
  // Make a test upload
  setTimeout(() => {
    const req = http.request({
      hostname: 'localhost',
      port: PORT,
      path: '/upload',
      method: 'POST',
      headers: {
        'Content-Type': 'text/plain'
      }
    }, (res) => {
      let data = '';
      res.on('data', (chunk) => { data += chunk; });
      res.on('end', () => {
        console.log('Upload response:', data);
      });
    });
    
    req.on('error', (e) => {
      console.error('Test request error:', e.message);
    });
    
    // Write some content to upload
    req.write('This is a test file content uploaded using http.request.\n');
    req.write('It demonstrates streaming data to the server.\n');
    req.end();
  }, 1000);
});

const http = require('http');
const zlib = require('zlib');

// Create an HTTP server that sends trailers
const server = http.createServer((req, res) => {
  // Inform the client we'll be sending trailers
  res.writeHead(200, {
    'Content-Type': 'text/plain',
    'Transfer-Encoding': 'chunked', // Required for trailers
    'Trailer': 'Content-MD5, X-Response-Time' // Declare which trailers will be sent
  });
  
  // Write some response data
  res.write('Beginning of the response\n');
  
  // Simulate processing time
  setTimeout(() => {
    res.write('Middle of the response\n');
    
    setTimeout(() => {
      // Final part of the body
      res.write('End of the response\n');
      
      // Add trailers
      res.addTrailers({
        'Content-MD5': 'e4e68fb7bd0e697a0ae8f1bb342846d3', // Would normally be the hash of the body
        'X-Response-Time': `${Date.now() - req.start}ms` // Processing time
      });
      
      // End the response
      res.end();
    }, 500);
  }, 500);
});

// Track request start time
server.on('request', (req) => {
  req.start = Date.now();
});

// Start server
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}/`);
  
  // Make a request to test trailers
  http.get(`http://localhost:${PORT}`, (res) => {
    console.log('Response status:', res.statusCode);
    console.log('Response headers:', res.headers);
    
    // Check if trailers are declared
    if (res.headers.trailer) {
      console.log('Trailer headers declared:', res.headers.trailer);
    }
    
    // Read the response body
    let body = '';
    
    res.on('data', (chunk) => {
      body += chunk;
      console.log('Received chunk:', chunk.toString());
    });
    
    // The 'end' event is emitted when the entire body has been received
    res.on('end', () => {
      console.log('Complete response body:', body);
      console.log('Trailers received:', res.trailers);
      
      // Server should close after test is complete
      server.close();
    });
  }).on('error', (err) => {
    console.error('Request error:', err);
  });
});

const http = require('http');

// Create a server to handle large uploads with flow control
const server = http.createServer((req, res) => {
  if (req.method === 'POST' && req.url === '/large-upload') {
    // Set up variables to track data
    let dataSize = 0;
    let chunks = 0;
    
    // Switch to pause mode (by default it's in flowing mode)
    req.pause();
    
    console.log('Incoming large upload - using flow control');
    
    // Process data in chunks
    function processNextChunk() {
      // Resume the stream to get more data
      req.resume();
      
      // Set a timeout to pause after a bit
      setTimeout(() => {
        // Pause the stream again
        req.pause();
        
        console.log(`Processed chunk ${++chunks}, total ${dataSize} bytes so far`);
        
        // If there's more data to process, schedule the next chunk
        // Otherwise, wait for 'end' event to finish
        if (!req.complete) {
          // Schedule next chunk processing
          setTimeout(processNextChunk, 100);
        }
      }, 100); // Process for 100ms, then pause
    }
    
    // Listen for data events
    req.on('data', (chunk) => {
      dataSize += chunk.length;
    });
    
    // Handle request end
    req.on('end', () => {
      console.log(`Upload complete: ${dataSize} bytes received in ${chunks} chunks`);
      
      // Send a response
      res.writeHead(200, {'Content-Type': 'application/json'});
      res.end(JSON.stringify({
        success: true,
        bytesReceived: dataSize,
        chunks: chunks
      }));
    });
    
    // Handle errors
    req.on('error', (err) => {
      console.error('Request error:', err);
      
      res.writeHead(500, {'Content-Type': 'text/plain'});
      res.end('Error processing upload: ' + err.message);
    });
    
    // Start processing
    processNextChunk();
  }
  else {
    // Handle other requests
    res.writeHead(404, {'Content-Type': 'text/plain'});
    res.end('Not Found');
  }
});

// Start server
const PORT = 8080;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}/`);
  
  // Create a test client to simulate large upload
  console.log('Simulating large upload...');
  
  const req = http.request({
    hostname: 'localhost',
    port: PORT,
    path: '/large-upload',
    method: 'POST',
    headers: {
      'Content-Type': 'application/octet-stream'
    }
  }, (res) => {
    // Handle response
    let responseData = '';
    
    res.on('data', (chunk) => {
      responseData += chunk;
    });
    
    res.on('end', () => {
      console.log('Server response:', responseData);
      
      // Close the server after the test
      server.close();
    });
  });
  
  req.on('error', (err) => {
    console.error('Upload request error:', err);
  });
  
  // Generate and send a large body in chunks
  function sendChunk(i, total) {
    if (i >= total) {
      // All chunks sent, end the request
      req.end();
      return;
    }
    
    // Create a 10KB chunk
    const chunk = Buffer.alloc(10240);
    chunk.fill(65 + (i % 26)); // Fill with repeating letters
    
    // Write the chunk
    const canContinue = req.write(chunk);
    
    // Log progress
    if (i % 10 === 0) {
      console.log(`Sent chunk ${i}/${total} (${i * 10240} bytes)`);
    }
    
    // If we can continue writing, schedule next chunk
    if (canContinue) {
      // Schedule next chunk
      setImmediate(() => sendChunk(i + 1, total));
    } else {
      // If backpressure is applied, wait for drain event
      console.log('Backpressure applied, waiting for drain');
      req.once('drain', () => {
        console.log('Drained, continuing upload');
        sendChunk(i + 1, total);
      });
    }
  }
  
  // Start sending chunks (50 chunks = ~500KB)
  sendChunk(0, 50);
});